home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / cmds / diff / dist / diff.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-02-19  |  16.3 KB  |  656 lines
  1. /* GNU DIFF main routine.
  2.    Copyright (C) 1988, 1989 Free Software Foundation, Inc.
  3.  
  4. This file is part of GNU DIFF.
  5.  
  6. GNU DIFF is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 1, or (at your option)
  9. any later version.
  10.  
  11. GNU DIFF is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with GNU DIFF; see the file COPYING.  If not, write to
  18. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19.  
  20. /* GNU DIFF was written by Mike Haertel, David Hayes,
  21.    Richard Stallman and Len Tower.  */
  22.  
  23. #define GDIFF_MAIN
  24. #include "regex.h"
  25. #include "diff.h"
  26. #include "getopt.h"
  27.  
  28.  
  29. /* Nonzero for -r: if comparing two directories,
  30.    compare their common subdirectories recursively.  */
  31.  
  32. int recursive;
  33.  
  34. /* For debugging: don't do discard_confusing_lines.  */
  35.  
  36. int no_discards;
  37.  
  38. /* Return a string containing the command options with which diff was invoked.
  39.    Spaces appear between what were separate ARGV-elements.
  40.    There is a space at the beginning but none at the end.
  41.    If there were no options, the result is an empty string.
  42.  
  43.    Arguments: OPTIONVEC, a vector containing separate ARGV-elements, and COUNT,
  44.    the length of that vector.  */
  45.  
  46. static char *
  47. option_list (optionvec, count)
  48.      char **optionvec;  /* Was `vector', but that collides on Alliant.  */
  49.      int count;
  50. {
  51.   int i;
  52.   int length = 0;
  53.   char *result;
  54.  
  55.   for (i = 0; i < count; i++)
  56.     length += strlen (optionvec[i]) + 1;
  57.  
  58.   result = (char *) xmalloc (length + 1);
  59.   result[0] = 0;
  60.  
  61.   for (i = 0; i < count; i++)
  62.     {
  63.       strcat (result, " ");
  64.       strcat (result, optionvec[i]);
  65.     }
  66.  
  67.   return result;
  68. }
  69.  
  70. static struct option longopts[] =
  71. {
  72.   {"ignore-blank-lines", 0, 0, 'B'},
  73.   {"context", 2, 0, 129},
  74.   {"ifdef", 1, 0, 'D'},
  75.   {"show-function-line", 1, 0, 'F'},
  76.   {"speed-large-files", 0, 0, 'H'},
  77.   {"ignore-matching-lines", 1, 0, 'I'},
  78.   {"entire-new-file", 0, 0, 'N'},
  79.   {"starting-file", 1, 0, 'S'},
  80.   {"initial-tab", 0, 0, 'T'},
  81.   {"text", 0, 0, 'a'},
  82.   {"all-text", 0, 0, 'a'},
  83.   {"ascii", 0, 0, 'a'},
  84.   {"ignore-space-change", 0, 0, 'b'},
  85.   {"minimal", 0, 0, 'd'},
  86.   {"ed", 0, 0, 'e'},
  87.   {"reversed-ed", 0, 0, 'f'},
  88.   {"ignore-case", 0, 0, 'i'},
  89.   {"print", 0, 0, 'l'},
  90.   {"rcs", 0, 0, 'n'},
  91.   {"show-c-function", 0, 0, 'p'},
  92.   {"binary", 0, 0, 'q'},
  93.   {"brief", 0, 0, 'q'},
  94.   {"recursive", 0, 0, 'r'},
  95.   {"report-identical-files", 0, 0, 's'},
  96.   {"expand-tabs", 0, 0, 't'},
  97.   {"ignore-all-space", 0, 0, 'w'},
  98.   {"version", 0, 0, 'v'},
  99.   {0, 0, 0, 0}
  100. };
  101.  
  102. main (argc, argv)
  103.      int argc;
  104.      char *argv[];
  105. {
  106.   int val;
  107.   int c;
  108.   int prev = -1;
  109.   int longind;
  110.   extern char *version_string;
  111.  
  112.   program = argv[0];
  113.  
  114.   /* Do our initializations. */
  115.   output_style = OUTPUT_NORMAL;
  116.   always_text_flag = FALSE;
  117.   ignore_space_change_flag = FALSE;
  118.   ignore_all_space_flag = FALSE;
  119.   length_varies = FALSE;
  120.   ignore_case_flag = FALSE;
  121.   ignore_blank_lines_flag = FALSE;
  122.   ignore_regexp = 0;
  123.   function_regexp = 0;
  124.   print_file_same_flag = FALSE;
  125.   entire_new_file_flag = FALSE;
  126.   no_details_flag = FALSE;
  127.   context = -1;
  128.   line_end_char = '\n';
  129.   tab_align_flag = FALSE;
  130.   tab_expand_flag = FALSE;
  131.   recursive = FALSE;
  132.   paginate_flag = FALSE;
  133.   ifdef_string = NULL;
  134.   heuristic = FALSE;
  135.   dir_start_file = NULL;
  136.   msg_chain = NULL;
  137.   msg_chain_end = NULL;
  138.   no_discards = 0;
  139.  
  140.   /* Decode the options.  */
  141.  
  142.   while ((c = getopt_long (argc, argv,
  143.                "0123456789abBcC:dD:efF:hHiI:lnNpqrsS:tTvw",
  144.                longopts, &longind)) != EOF)
  145.     {
  146.       if (c == 0)        /* Long option. */
  147.     c = longopts[longind].val;
  148.       switch (c)
  149.     {
  150.       /* All digits combine in decimal to specify the context-size.  */
  151.     case '1':
  152.     case '2':
  153.     case '3':
  154.     case '4':
  155.     case '5':
  156.     case '6':
  157.     case '7':
  158.     case '8':
  159.     case '9':
  160.     case '0':
  161.       if (context == -1)
  162.         context = 0;
  163.       /* If a context length has already been specified,
  164.          more digits allowed only if they follow right after the others.
  165.          Reject two separate runs of digits, or digits after -C.  */
  166.       else if (prev < '0' || prev > '9')
  167.         fatal ("context length specified twice");
  168.  
  169.       context = context * 10 + c - '0';
  170.       break;
  171.  
  172.     case 'a':
  173.       /* Treat all files as text files; never treat as binary.  */
  174.       always_text_flag = 1;
  175.       break;
  176.  
  177.     case 'b':
  178.       /* Ignore changes in amount of whitespace.  */
  179.       ignore_space_change_flag = 1;
  180.       length_varies = 1;
  181.       break;
  182.  
  183.     case 'B':
  184.       /* Ignore changes affecting only blank lines.  */
  185.       ignore_blank_lines_flag = 1;
  186.       break;
  187.  
  188.     case 'C':
  189.     case 129:        /* +context[=lines] */
  190.       if (optarg)
  191.         {
  192.           if (context >= 0)
  193.         fatal ("context length specified twice");
  194.           {
  195.         char *p;
  196.         for (p = optarg; *p; p++)
  197.           if (*p < '0' || *p > '9')
  198.             fatal ("invalid context length argument");
  199.           }
  200.           context = atoi (optarg);
  201.         }
  202.  
  203.       /* Falls through.  */
  204.     case 'c':
  205.       /* Make context-style output.  */
  206.       specify_style (OUTPUT_CONTEXT);
  207.       break;
  208.  
  209.     case 'd':
  210.       /* Don't discard lines.  This makes things slower (sometimes much
  211.          slower) but will find a guaranteed minimal set of changes.  */
  212.       no_discards = 1;
  213.       break;
  214.  
  215.     case 'D':
  216.       /* Make merged #ifdef output.  */
  217.       specify_style (OUTPUT_IFDEF);
  218.       ifdef_string = optarg;
  219.       break;
  220.  
  221.     case 'e':
  222.       /* Make output that is a valid `ed' script.  */
  223.       specify_style (OUTPUT_ED);
  224.       break;
  225.  
  226.     case 'f':
  227.       /* Make output that looks vaguely like an `ed' script
  228.          but has changes in the order they appear in the file.  */
  229.       specify_style (OUTPUT_FORWARD_ED);
  230.       break;
  231.  
  232.     case 'F':
  233.       /* Show, for each set of changes, the previous line that
  234.          matches the specified regexp.  Currently affects only
  235.          context-style output.  */
  236.       function_regexp = optarg;
  237.       break;
  238.  
  239.     case 'h':
  240.       /* Split the files into chunks of around 1500 lines
  241.          for faster processing.  Usually does not change the result.
  242.  
  243.          This currently has no effect.  */
  244.       break;
  245.  
  246.     case 'H':
  247.       /* Turn on heuristics that speed processing of large files
  248.          with a small density of changes.  */
  249.       heuristic = 1;
  250.       break;
  251.  
  252.     case 'i':
  253.       /* Ignore changes in case.  */
  254.       ignore_case_flag = 1;
  255.       break;
  256.  
  257.     case 'I':
  258.       /* Ignore changes affecting only lines that match the
  259.          specified regexp.  */
  260.       ignore_regexp = optarg;
  261.       break;
  262.  
  263.     case 'l':
  264.       /* Pass the output through `pr' to paginate it.  */
  265.       paginate_flag = 1;
  266.       break;
  267.  
  268.     case 'n':
  269.       /* Output RCS-style diffs, like `-f' except that each command
  270.          specifies the number of lines affected.  */
  271.       specify_style (OUTPUT_RCS);
  272.       break;
  273.  
  274.     case 'N':
  275.       /* When comparing directories, if a file appears only in one
  276.          directory, treat it as present but empty in the other.  */
  277.       entire_new_file_flag = 1;
  278.       break;
  279.  
  280.     case 'p':
  281.       /* Make context-style output and show name of last C function.  */
  282.       specify_style (OUTPUT_CONTEXT);
  283.       function_regexp = "^[_a-zA-Z]";
  284.       break;
  285.  
  286.     case 'q':
  287.       no_details_flag = 1;
  288.       break;
  289.  
  290.     case 'r':
  291.       /* When comparing directories, 
  292.          recursively compare any subdirectories found.  */
  293.       recursive = 1;
  294.       break;
  295.  
  296.     case 's':
  297.       /* Print a message if the files are the same.  */
  298.       print_file_same_flag = 1;
  299.       break;
  300.  
  301.     case 'S':
  302.       /* When comparing directories, start with the specified
  303.          file name.  This is used for resuming an aborted comparison.  */
  304.       dir_start_file = optarg;
  305.       break;
  306.  
  307.     case 't':
  308.       /* Expand tabs to spaces in the output so that it preserves
  309.          the alignment of the input files.  */
  310.       tab_expand_flag = 1;
  311.       break;
  312.  
  313.     case 'T':
  314.       /* Use a tab in the output, rather than a space, before the
  315.          text of an input line, so as to keep the proper alignment
  316.          in the input line without changing the characters in it.  */
  317.       tab_align_flag = 1;
  318.       break;
  319.  
  320.     case 'v':
  321.       printf ("GNU diff version %s\n", version_string);
  322.       break;
  323.  
  324.     case 'w':
  325.       /* Ignore horizontal whitespace when comparing lines.  */
  326.       ignore_all_space_flag = 1;
  327.       length_varies = 1;
  328.       break;
  329.  
  330.     default:
  331.       usage ();
  332.     }
  333.       prev = c;
  334.     }
  335.  
  336.   if (optind != argc - 2)
  337.     usage ();
  338.  
  339.   if (ignore_regexp)
  340.     {
  341.       char *val;
  342.       bzero (&ignore_regexp_compiled, sizeof ignore_regexp_compiled);
  343.       val = re_compile_pattern (ignore_regexp, strlen (ignore_regexp),
  344.                 &ignore_regexp_compiled);
  345.       if (val != 0)
  346.     error ("regexp to ignore: ", val);
  347.       ignore_regexp_compiled.fastmap = (char *) xmalloc (256);
  348.     }
  349.  
  350.   if (function_regexp)
  351.     {
  352.       char *val;
  353.       bzero (&function_regexp_compiled, sizeof function_regexp_compiled);
  354.       val = re_compile_pattern (function_regexp, strlen (function_regexp),
  355.                 &function_regexp_compiled);
  356.       if (val != 0)
  357.     error ("regexp for previous line: ", val);
  358.       function_regexp_compiled.fastmap = (char *) xmalloc (256);
  359.     }
  360.  
  361.   if (output_style != OUTPUT_CONTEXT)
  362.     context = 0;
  363.   else if (context == -1)
  364.     /* Default amount of context for -c.  */
  365.     context = 3;
  366.  
  367.   switch_string = option_list (argv + 1, optind - 1);
  368.  
  369.   val = compare_files (0, argv[optind], 0, argv[optind + 1], 0);
  370.  
  371.   /* Print any messages that were saved up for last.  */
  372.   print_message_queue ();
  373.  
  374.   exit (val);
  375. }
  376.  
  377. usage ()
  378. {
  379.   fprintf (stderr, "\
  380. Usage: diff [-#] [-abBcdefhHilnNprstTvw] [-C lines] [-F regexp] [-I regexp]\n\
  381.        [-S file] [-D symbol] [+ignore-blank-lines] [+context[=lines]]\n\
  382.        [+ifdef symbol] [+show-function-line regexp] [+speed-large-files]\n");
  383.   fprintf (stderr, "\
  384.        [+ignore-matching-lines regexp] [+entire-new-file] [+initial-tab]\n\
  385.        [+starting-file file] [+text] [+all-text] [+ascii] [+minimal]\n\
  386.        [+ignore-space-change] [+ed] [+reversed-ed] [+ignore-case] [+print]\n");
  387.   fprintf (stderr, "\
  388.        [+rcs] [+show-c-function] [+binary] [+brief] [+recursive]\n\
  389.        [+report-identical-files] [+expand-tabs] [+ignore-all-space]\n\
  390.        [+version] path1 path2\n");
  391.   exit (1);
  392. } 
  393.  
  394. specify_style (style)
  395.      enum output_style style;
  396. {
  397.   if (output_style != OUTPUT_NORMAL
  398.       && output_style != style)
  399.     error ("conflicting specifications of output style");
  400.   output_style = style;
  401. }
  402.  
  403. /* Compare two files (or dirs) with specified names
  404.    DIR0/NAME0 and DIR1/NAME1, at level DEPTH in directory recursion.
  405.    (if DIR0 is 0, then the name is just NAME0, etc.)
  406.    This is self-contained; it opens the files and closes them.
  407.  
  408.    Value is 0 if files are identical, 1 if different,
  409.    2 if there is a problem opening them.  */
  410.  
  411. int
  412. compare_files (dir0, name0, dir1, name1, depth)
  413.      char *dir0, *dir1;
  414.      char *name0, *name1;
  415.      int depth;
  416. {
  417.   struct file_data inf[2];
  418.   register int i;
  419.   int val;
  420.   int errorcount = 0;
  421.   int stat_result[2];
  422.  
  423.   /* If this is directory comparison, perhaps we have a file
  424.      that exists only in one of the directories.
  425.      If so, just print a message to that effect.  */
  426.  
  427.   if (! entire_new_file_flag && (name0 == 0 || name1 == 0))
  428.     {
  429.       char *name = name0 == 0 ? name1 : name0;
  430.       char *dir = name0 == 0 ? dir1 : dir0;
  431.       message ("Only in %s: %s\n", dir, name);
  432.       /* Return 1 so that diff_dirs will return 1 ("some files differ").  */
  433.       return 1;
  434.     }
  435.  
  436.   /* Mark any nonexistent file with -1 in the desc field.  */
  437.  
  438.   inf[0].desc = name0 == 0 ? -1 : 0;
  439.   inf[1].desc = name1 == 0 ? -1 : 0;
  440.  
  441.   /* Now record the full name of each file, including nonexistent ones.  */
  442.  
  443.   if (name0 == 0)
  444.     name0 = name1;
  445.   if (name1 == 0)
  446.     name1 = name0;
  447.  
  448.   inf[0].name = dir0 == 0 ? name0 : concat (dir0, "/", name0);
  449.   inf[1].name = dir1 == 0 ? name1 : concat (dir1, "/", name1);
  450.  
  451.   /* Stat the files.  Record whether they are directories.
  452.      Record in stat_result whether stat fails.  */
  453.  
  454.   for (i = 0; i <= 1; i++)
  455.     {
  456.       bzero (&inf[i].stat, sizeof(struct stat));
  457.       inf[i].dir_p = 0;
  458.       stat_result[i] = 0;
  459.  
  460.       if (inf[i].desc != -1
  461.       && strcmp (inf[i].name, "-"))
  462.     {
  463.       char *filename = inf[i].name;
  464.  
  465.       stat_result[i] = stat (filename, &inf[i].stat);
  466.       if (stat_result[i] < 0)
  467.         {
  468.           perror_with_name (filename);
  469.           errorcount = 1;
  470.         }
  471.       else
  472.         inf[i].dir_p = (S_IFDIR == (inf[i].stat.st_mode & S_IFMT));
  473.     }
  474.     }
  475.  
  476.   /* See if the two named files are actually the same physical file.
  477.      If so, we know they are identical without actually reading them.  */
  478.  
  479.   if (inf[0].stat.st_ino == inf[1].stat.st_ino
  480.       && inf[0].stat.st_dev == inf[1].stat.st_dev
  481.       && stat_result[0] == 0
  482.       && stat_result[1] == 0)
  483.     {
  484.       val = 0;
  485.       goto done;
  486.     }
  487.  
  488.   if (name0 == 0)
  489.     inf[0].dir_p = inf[1].dir_p;
  490.   if (name1 == 0)
  491.     inf[1].dir_p = inf[0].dir_p;
  492.  
  493.   /* Open the files and record their descriptors.  */
  494.  
  495.   for (i = 0; i <= 1; i++)
  496.     {
  497.       if (inf[i].desc == -1)
  498.     ;
  499.       else if (!strcmp (inf[i].name, "-"))
  500.     {
  501.       inf[i].desc = 0;
  502.       inf[i].name = "Standard Input";
  503.     }
  504.       /* Don't bother opening if stat already failed.  */
  505.       else if (stat_result[i] == 0 && ! inf[i].dir_p)
  506.     {
  507.       char *filename = inf[i].name;
  508.  
  509.       inf[i].desc = open (filename, O_RDONLY, 0);
  510.       if (0 > inf[i].desc)
  511.         {
  512.           perror_with_name (filename);
  513.           errorcount = 1;
  514.         }
  515.     }
  516.     }
  517.  
  518.   if (errorcount)
  519.     {
  520.  
  521.       /* If either file should exist but fails to be opened, return 2.  */
  522.  
  523.       val = 2;
  524.  
  525.     }
  526.   else if (inf[0].dir_p && inf[1].dir_p)
  527.     {
  528.       if (output_style == OUTPUT_IFDEF)
  529.     fatal ("-D option not supported with directories");
  530.  
  531.       /* If both are directories, compare the files in them.  */
  532.  
  533.       if (depth > 0 && !recursive)
  534.     {
  535.       /* But don't compare dir contents one level down
  536.          unless -r was specified.  */
  537.       message ("Common subdirectories: %s and %s\n",
  538.            inf[0].name, inf[1].name);
  539.       val = 0;
  540.     }
  541.       else
  542.     {
  543.       val = diff_dirs (inf[0].name, inf[1].name, 
  544.                compare_files, depth, 0, 0);
  545.     }
  546.  
  547.     }
  548.   else if (depth == 0 && (inf[0].dir_p || inf[1].dir_p))
  549.     {
  550.  
  551.       /* If only one is a directory, and it was specified in the command line,
  552.      use the file in that dir whose basename matches the other file.  */
  553.  
  554.       int dir_arg = (inf[0].dir_p ? 0 : 1);
  555.       int fnm_arg = (inf[0].dir_p ? 1 : 0);
  556.       char *p = rindex (inf[fnm_arg].name, '/');
  557.       char *filename = concat (inf[dir_arg].name,  "/",
  558.                    (p ? p+1 : inf[fnm_arg].name));
  559.  
  560.       inf[dir_arg].desc = open (filename, O_RDONLY, 0);
  561.  
  562.       if (0 > inf[dir_arg].desc)
  563.     {
  564.       perror_with_name (filename);
  565.       val = 2;
  566.     }
  567.       else
  568.     {
  569.       /* JF: patch from the net to check and make sure we can really free
  570.          this.  If it's from argv[], freeing it is a *really* bad idea */
  571.       if (0 != (dir_arg ? dir1 : dir0))
  572.         free (inf[dir_arg].name);
  573.       inf[dir_arg].name = filename;
  574.       if (fstat (inf[dir_arg].desc, &inf[dir_arg].stat) < 0)
  575.         pfatal_with_name (inf[dir_arg].name);
  576.  
  577.       inf[dir_arg].dir_p
  578.         = (S_IFDIR == (inf[dir_arg].stat.st_mode & S_IFMT));
  579.       if (inf[dir_arg].dir_p)
  580.         {
  581.           error ("%s is a directory but %s is not",
  582.              inf[dir_arg].name, inf[fnm_arg].name);
  583.           val = 1;
  584.         }
  585.       else
  586.         val = diff_2_files (inf, depth);
  587.     }
  588.  
  589.     }
  590.   else if (depth > 0 && (inf[0].dir_p || inf[1].dir_p))
  591.     {
  592.       /* Perhaps we have a subdirectory that exists only in one directory.
  593.      If so, just print a message to that effect.  */
  594.  
  595.       if (inf[0].desc == -1 || inf[1].desc == -1)
  596.     {
  597.       if (entire_new_file_flag && recursive)
  598.         val = diff_dirs (inf[0].name, inf[1].name, compare_files, depth,
  599.                  inf[0].desc == -1, inf[1].desc == -1);
  600.       else
  601.         {
  602.           char *dir = (inf[0].desc == -1) ? dir1 : dir0;
  603.           message ("Only in %s: %s\n", dir, name0);
  604.           val = 1;
  605.         }
  606.     }
  607.       else
  608.     {
  609.       /* We have a subdirectory in one directory
  610.          and a file in the other.  */
  611.  
  612.       if (inf[0].dir_p)
  613.         message ("%s is a directory but %s is not\n",
  614.              inf[0].name, inf[1].name);
  615.       else
  616.         message ("%s is a directory but %s is not\n",
  617.              inf[1].name, inf[0].name);
  618.       /* This is a difference.  */
  619.       val = 1;
  620.     }
  621.     }
  622.   else
  623.     {
  624.  
  625.       /* Both exist and both are ordinary files.  */
  626.  
  627.       val = diff_2_files (inf, depth);
  628.  
  629.     }
  630.  
  631.   /* Now the comparison has been done, if no error prevented it,
  632.      and VAL is the value this function will return.  */
  633.  
  634.   if (inf[0].desc > 0)
  635.     close (inf[0].desc);
  636.   if (inf[1].desc > 0)
  637.     close (inf[1].desc);
  638.  
  639.  done:
  640.   if (val == 0 && !inf[0].dir_p)
  641.     {
  642.       if (print_file_same_flag)
  643.     message ("Files %s and %s are identical\n",
  644.          inf[0].name, inf[1].name);
  645.     }
  646.   else
  647.     fflush (stdout);
  648.  
  649.   if (dir0 != 0)
  650.     free (inf[0].name);
  651.   if (dir1 != 0)
  652.     free (inf[1].name);
  653.  
  654.   return val;
  655. }
  656.